Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

src/__tests__/all.test.ts (1)

444-458: Fold this into the existing successful disposer test.

This covers the same success path as the earlier disposer-cleanup case at Lines 429-442. Moving the result assertion into that test would keep the suite smaller without losing coverage.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/__tests__/all.test.ts` around lines 444 - 458, Remove the duplicate test
"allows disposer usage in a successful task without external cancellation" and
fold its assertions into the existing successful-disposer test that already
registers a disposer via this.$disposer.defer; specifically, in that existing
test (the one that verifies disposer cleanup on success) call or reuse the same
try$.all invocation, add the expectation expect(result).toEqual({ a: 1 })
immediately after the await, and keep the existing expect(cleaned).toBe(true)
assertion so the success path and cleanup are both verified in one test.

src/lib/executors/base.ts (1)

255-257: Let TypeScript infer the private getter type.

#wrapCtx is private, and inference already gives the correct type here, so the explicit annotation just adds noise.

♻️ Suggested cleanup

-  get `#wrapCtx`(): WrapCtx {
+  get `#wrapCtx`() {
     this.#wrapCtxCache ??= BaseExecution.createWrapContext(this.ctx)
     return this.#wrapCtxCache
   }

As per coding guidelines, **/*.{ts,tsx}: Prefer type inference whenever possible in TypeScript; Do not add explicit return types unless required by tooling, declaration emit, or a public API contract; Do not use explicit return types when inference already produces the correct result.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/lib/executors/base.ts` around lines 255 - 257, Remove the explicit return
type on the private getter get `#wrapCtx`(): WrapCtx and let TypeScript infer the
type; modify the getter in the BaseExecution-derived class so it simply declares
get `#wrapCtx`() { this.#wrapCtxCache ??=
BaseExecution.createWrapContext(this.ctx); return this.#wrapCtxCache; } (keeping
references to `#wrapCtxCache`, BaseExecution.createWrapContext and this.ctx
intact) to comply with the inference guideline.

src/lib/__tests__/coverage-exceptions.test.ts (1)

139-195: Add one bare-thenable regression here.

These cases only exercise native Promise instances, but the production change is specifically about PromiseLike. A small { then(...) { ... } } case in this block would catch any remaining Promise-only assumptions in resolveWithAbort() and the updated race() paths.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/lib/__tests__/coverage-exceptions.test.ts` around lines 139 - 195, Add a
bare-thenable variant of the existing Promise tests to exercise PromiseLike
handling: create a thenable object (e.g., pendingThenable with a then(resolve)
implementation that stores the resolve function), pass it into
resolveWithAbort(controller.signal, pendingThenable, createAbortResult) and
assert the same behaviors as the Promise tests (returns the resolved value if
thenable settles before abort, returns the abort value if abort wins, and ensure
the abort factory is called exactly once when abort wins); reuse the same helper
names and assertions (resolveWithAbort, controller.abort, and the abort factory
counter) so the test sits alongside the existing cases and will catch any
Promise-only assumptions in resolveWithAbort and race paths.

src/__tests__/all.test.ts (1)

444-458: Consider consolidating with existing test.

This test appears to largely duplicate the existing test at lines 429-442 ("runs disposer cleanup after all tasks complete"). Both tests:

• Use a successful task with this.$disposer.defer()
• Verify cleaned becomes true
• Do not use external cancellation

The only difference is the additional expect(result).toEqual({ a: 1 }) assertion, which is already covered by numerous other tests in this file.

If there's a specific behavioral distinction intended by "allows disposer usage in a successful task without external cancellation," consider adding a clarifying comment or renaming the existing test to better distinguish them. Otherwise, this test could be removed to avoid redundancy.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/__tests__/all.test.ts` around lines 444 - 458, The test "allows disposer
usage in a successful task without external cancellation" duplicates the earlier
"runs disposer cleanup after all tasks complete" test; either remove this
redundant test block or consolidate its additional assertion into the existing
test: merge the expect(result).toEqual({ a: 1 }) into the earlier test that uses
try$.all and this.$disposer.defer (the test function that sets cleaned and
verifies cleanup), or alternatively rename the earlier test to reflect both
cleanup and return-value expectations and add a clarifying comment; ensure you
update or remove the duplicate test that references try$.all,
this.$disposer.defer, cleaned and result accordingly.

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

Your team has set up Codex to review pull requests in this repo. Reviews are triggered when you

• Open a pull request for review
• Mark a draft as ready
• Comment "@codex review".

If Codex has suggestions, it will comment; otherwise it will react with 👍.

Codex can also answer questions or update the PR. Try commenting "@codex address that feedback".

src/__tests__/all-settled.test.ts (1)

247-250: Make the wrap cleanup assertion cover sync throws too.

Promise.resolve(next()) only reaches .finally(...) if next() returns. A synchronous throw bypasses the cleanup, so this test currently proves the async path only. Promise.resolve().then(() => next()).finally(...) covers both.

Suggested fix

         .wrap((_, next) =>
-          Promise.resolve(next()).finally(() => {
-            cleaned = true
-          })
+          Promise.resolve()
+            .then(() => next())
+            .finally(() => {
+              cleaned = true
+            })
         )

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/__tests__/all-settled.test.ts` around lines 247 - 250, The cleanup in the
.wrap call currently uses Promise.resolve(next()).finally(...), which won't run
.finally if next() throws synchronously; change it to use
Promise.resolve().then(() => next()).finally(...) so the finally handler
(setting cleaned = true) runs for both synchronous throws and async rejections —
update the .wrap((_, next) => ...) invocation that sets cleaned to true
accordingly and keep the existing finally body.

src/__tests__/flow.test.ts (1)

240-243: Use the same cleanup wrapper shape that handles sync throws.

This has the same gap as the allSettled() test: Promise.resolve(next()) skips .finally(...) if next() throws synchronously. Wrapping the call in .then(() => next()) makes the cleanup assertion resilient to both sync and async failure paths.

Suggested fix

         .wrap((_, next) =>
-          Promise.resolve(next()).finally(() => {
-            cleaned = true
-          })
+          Promise.resolve()
+            .then(() => next())
+            .finally(() => {
+              cleaned = true
+            })
         )

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@src/__tests__/flow.test.ts` around lines 240 - 243, The cleanup wrapper
currently uses Promise.resolve(next()) which bypasses the .finally handler when
next() throws synchronously; update the wrapper used in the .wrap(...) call to
invoke next() through a resolved promise (e.g., use Promise.resolve().then(() =>
next())) so that .finally(...) always runs and the cleaned flag assertion
(variable cleaned) is resilient to both sync and async failures — mirror the
same fix applied in the allSettled() test to ensure synchronous throws from
next() still trigger cleanup.